/**
 * 解析十六进制颜色
 */
export const parseHexColor = (
  hex: string
): {
  r: number;
  g: number;
  b: number;
  a: number;
} => {
  let cleanHex = hex.slice(1);

  // 处理3位十六进制 #RGB
  if (cleanHex.length === 3) {
    cleanHex = cleanHex
      .split("")
      .map((c) => c + c)
      .join("");
  }
  // 处理4位十六进制 #RGBA
  else if (cleanHex.length === 4) {
    cleanHex = cleanHex
      .split("")
      .map((c) => c + c)
      .join("");
  }
  // 处理6位十六进制 #RRGGBB
  else if (cleanHex.length === 6) {
    // 已经是6位，无需处理
  }
  // 处理8位十六进制 #RRGGBBAA
  else if (cleanHex.length === 8) {
    // 已经是8位，无需处理
  } else {
    console.warn(`无效的十六进制颜色格式: ${hex}`);
    return { r: 0, g: 0, b: 0, a: 255 };
  }

  const r = parseInt(cleanHex.slice(0, 2), 16) || 0;
  const g = parseInt(cleanHex.slice(2, 4), 16) || 0;
  const b = parseInt(cleanHex.slice(4, 6), 16) || 0;
  const a =
    cleanHex.length === 8 ? parseInt(cleanHex.slice(6, 8), 16) || 0 : 255;

  return { r, g, b, a };
};

/**
 * 解析rgba()格式颜色
 */
export const parseRgbaColor = (
  rgba: string
): {
  r: number;
  g: number;
  b: number;
  a: number;
} => {
  try {
    // 提取括号内的内容：rgba(55, 65, 81, 0.4) -> 55, 65, 81, 0.4
    const content = rgba.slice(5, -1);
    const values = content.split(",").map((v) => v.trim());

    if (values.length !== 4) {
      throw new Error("rgba格式需要4个值");
    }

    const r = Math.max(0, Math.min(255, parseInt(values[0]) || 0));
    const g = Math.max(0, Math.min(255, parseInt(values[1]) || 0));
    const b = Math.max(0, Math.min(255, parseInt(values[2]) || 0));
    const a = Math.max(
      0,
      Math.min(255, Math.round(parseFloat(values[3]) * 255) || 255)
    );

    return { r, g, b, a };
  } catch (error) {
    console.warn(`解析rgba颜色失败: ${rgba}`, error);
    return { r: 0, g: 0, b: 0, a: 255 };
  }
};

/**
 * 解析rgb()格式颜色
 */
export const parseRgbColor = (
  rgb: string
): {
  r: number;
  g: number;
  b: number;
  a: number;
} => {
  try {
    // 提取括号内的内容：rgb(55, 65, 81) -> 55, 65, 81
    const content = rgb.slice(4, -1);
    const values = content.split(",").map((v) => v.trim());

    if (values.length !== 3) {
      throw new Error("rgb格式需要3个值");
    }

    const r = Math.max(0, Math.min(255, parseInt(values[0]) || 0));
    const g = Math.max(0, Math.min(255, parseInt(values[1]) || 0));
    const b = Math.max(0, Math.min(255, parseInt(values[2]) || 0));

    return { r, g, b, a: 255 };
  } catch (error) {
    console.warn(`解析rgb颜色失败: ${rgb}`, error);
    return { r: 0, g: 0, b: 0, a: 255 };
  }
};

/**
 * 解析颜色字符串为RGBA值
 * 支持格式：#RGB, #RGBA, #RRGGBB, #RRGGBBAA, rgba(r,g,b,a), rgb(r,g,b)
 */
export const parseColorToRGBA = (
  color: string
): {
  r: number;
  g: number;
  b: number;
  a: number;
} => {
  if (!color || typeof color !== "string") {
    return { r: 0, g: 0, b: 0, a: 255 };
  }

  const trimmedColor = color.trim();

  // 处理十六进制格式
  if (trimmedColor.startsWith("#")) {
    return parseHexColor(trimmedColor);
  }

  // 处理rgba()格式
  if (trimmedColor.startsWith("rgba(") && trimmedColor.endsWith(")")) {
    return parseRgbaColor(trimmedColor);
  }

  // 处理rgb()格式
  if (trimmedColor.startsWith("rgb(") && trimmedColor.endsWith(")")) {
    return parseRgbColor(trimmedColor);
  }

  // 默认返回黑色
  console.warn(`不支持的颜色格式: ${color}`);
  return { r: 0, g: 0, b: 0, a: 255 };
};

/**
 * 将10进制的buffer数组转换为16进制字符串数组
 * @param buffer 10进制数字数组
 * @returns 16进制字符串数组，每个元素都是 "0x" 开头的16进制表示
 */
export function bufferToHexArray(buffer: number[]): string[] {
  return buffer.map((num) => {
    // 确保是有效的数字，并限制在0-255范围内
    const validNum = Math.max(0, Math.min(255, Math.floor(num || 0)));
    // 转换为16进制，补零到2位，添加0x前缀
    return `${validNum.toString(16).padStart(2, "0")}`;
  });
}
